// dh-hospitals 云对象 - 医院信息管理
const db = uniCloud.database();
const _ = db.command;
const { softDelete, batchSoftDelete } = require('dh-common');

/**
 * 统一响应格式化辅助函数
 */
function formatResponse(code, data = null, message = 'success', extraFields = {}) {
	return {
		code,
		data,
		message,
		success: (code === 200 || code === 201),
		timestamp: Date.now(),
		...extraFields
	};
}

/**
 * 统一错误响应辅助函数
 */
function formatError(error, defaultMessage = '操作失败') {
	console.error('[dh-hospitals] 错误:', error);
	return {
		code: 500,
		message: error.message || defaultMessage,
		success: false,
		timestamp: Date.now()
	};
}

module.exports = {

	/**
	 * 请求前拦截 - 全局权限检查、参数验证
	 */
	async _before(methodName, params) {
		// 1. 验证身份
		const uniIdToken = this.getUniIdToken();
		console.log(`[dh-hospitals] 调用方法: ${methodName}, 用户ID: ${uniIdToken?.uid}`);

		// 2. 写操作权限检查
		const writeMethods = ['create', 'update', 'delete', 'batch'];
		if (methodName && writeMethods.some(method => methodName.toLowerCase().includes(method))) {
			if (!uniIdToken || !uniIdToken.uid) {
				throw new Error('401|未授权的访问');
			}
			// 可以在这里添加更细粒度的权限检查
		}

		// 3. 参数清理和验证
		if (params && typeof params === 'object') {
			for (let key in params) {
				if (typeof params[key] === 'string') {
					params[key] = params[key].trim();
				}
			}
		}
	},

	/**
	 * 响应后处理 - 统一格式化、日志记录
	 * 注意：由于 uniCloud 云对象在某些情况下 _after 接收不到返回值
	 * 所以每个方法都需要直接返回完整格式的数据
	 */
	// async _after(result, methodName, params) {
	// 	// 如果是异常或失败结果，直接返回
	// 	if (result instanceof Error) {
	// 		return {
	// 			code: 500,
	// 			message: result.message,
	// 			success: false,
	// 			timestamp: Date.now()
	// 		};
	// 	}

	// 	if (!result) {
	// 		return { code: 500, message: '方法未返回结果', success: false, timestamp: Date.now() };
	// 	}

	// 	// 如果已经包含完整格式（有 success 和 timestamp 字段），直接返回
	// 	if (result.hasOwnProperty('success') && result.hasOwnProperty('timestamp')) {
	// 		return result;
	// 	}

	// 	// 否则进行格式化
	// 	return {
	// 		code: result.code || 200,
	// 		data: result.data || null,
	// 		message: result.message || 'success',
	// 		success: (result.code === 200 || result.code === 201),
	// 		timestamp: Date.now()
	// 	};
	// },

	/**
	 * 查询单个医院
	 */
	async getHospital(id) {
		try {
			if (!id) {
				return formatResponse(400, null, '医院ID不能为空');
			}

			const res = await db.collection('dh-hospitals').doc(id).get();
			if (res.data.length === 0) {
				return formatResponse(404, null, '医院不存在');
			}
			
			const hospital = res.data[0];
			// 检查是否已软删除
			if (hospital.is_deleted === true) {
				return formatResponse(404, null, '医院不存在或已删除');
			}
			
			return formatResponse(200, hospital);
		} catch (error) {
			return formatError(error, '获取医院信息失败');
		}
	},

	/**
	 * 获取医院列表
	 */
	async listHospitals(query = {}, skip = 0, limit = 20) {
		try {
			// 确保参数类型正确，排除数组、null等
			if (typeof query !== 'object' || query === null || Array.isArray(query)) {
				query = {};
			}
			skip = parseInt(skip) || 0;
			limit = parseInt(limit) || 20;
			
			// 构建查询条件，排除已软删除的记录
			const whereCondition = {
				...query,
				is_deleted: false  // 只查询 is_deleted 为 false 的记录
			};
			
			const res = await db.collection('dh-hospitals')
				.where(whereCondition)
				.skip(skip)
				.limit(limit)
				.get();
			
			// data 直接是数组，count 作为额外字段
			return formatResponse(200, res.data, 'success', { count: res.data.length });
		} catch (error) {
			return formatError(error, '获取医院列表失败');
		}
	},

	/**
	 * 创建医院信息
	 * ⚠️ 单一医院系统限制：只允许创建1条医院记录
	 */
	async createHospital(data) {
		try {
			if (!data.hospital_name) {
				return formatResponse(400, null, '医院名称不能为空');
			}

			// 🔒 单一医院系统限制：检查是否已存在医院
			const existingCount = await db.collection('dh-hospitals').count()
			const count = existingCount.total || 0
			
			if (count > 0) {
				return formatResponse(409, null, '系统仅支持单一医院，已存在医院记录，请编辑现有医院信息而非创建新医院');
			}

			const hospitalData = {
				hospital_name: data.hospital_name,
				address: data.address || '',
				phone: data.phone || '',
				introduction: data.introduction || '',
				logo: data.logo || null,
				banner: data.banner || null,
				working_hours_start: data.working_hours_start || '08:00',
				working_hours_end: data.working_hours_end || '18:00',
				closed_days: data.closed_days || [],
				parking_info: data.parking_info || '',
				public_transport: data.public_transport || '',
				business_license: data.business_license || '',
				medical_license: data.medical_license || '',
				rating: data.rating || 0,
				total_reviews: data.total_reviews || 0,
				is_deleted: false,  // 软删除字段，默认未删除
				create_time: Date.now(),
				update_time: Date.now()
			};

			const res = await db.collection('dh-hospitals').add(hospitalData);
			return formatResponse(201, { _id: res.id }, '医院信息创建成功');
		} catch (error) {
			return formatError(error, '创建医院失败');
		}
	},

	/**
	 * 更新医院信息
	 */
	async updateHospital(id, data) {
		try {
			if (!id) {
				return formatResponse(400, null, '医院ID不能为空');
			}

			const updateData = {
				...data,
				update_time: Date.now()
			};

			await db.collection('dh-hospitals').doc(id).update(updateData);
			return formatResponse(200, null, '医院信息更新成功');
		} catch (error) {
			return formatError(error, '更新医院失败');
		}
	},

	/**
	 * 删除医院信息（软删除）
	 * @param {string} id - 医院ID
	 * @param {string} reason - 删除原因（可选）
	 */
	async deleteHospital(id, reason = '') {
		try {
			if (!id) {
				return formatResponse(400, null, '医院ID不能为空');
			}

			const uniIdToken = this.getUniIdToken();
			const result = await softDelete('dh-hospitals', id, uniIdToken?.uid || '', reason);
			
			if (result.code === 200) {
				return formatResponse(200, null, '医院已移至回收站');
			} else {
				return formatResponse(result.code, null, result.message);
			}
		} catch (error) {
			return formatError(error, '删除医院失败');
		}
	},

	/**
	 * 批量更新医院信息
	 */
	async batchUpdateHospitals(updates) {
		try {
			if (!Array.isArray(updates) || updates.length === 0) {
				return formatResponse(400, null, '更新数据不能为空');
			}

			const promises = updates.map(item =>
				db.collection('dh-hospitals').doc(item._id).update({
					...item,
					update_time: Date.now()
				})
			);

			await Promise.all(promises);
			return formatResponse(200, null, `批量更新${updates.length}条记录成功`);
		} catch (error) {
			return formatError(error, '批量更新失败');
		}
	},

	/**
	 * 批量删除医院信息（软删除）
	 */
	async batchDeleteHospitals(ids, reason = '') {
		try {
			if (!Array.isArray(ids) || ids.length === 0) {
				return formatResponse(400, null, 'ID列表不能为空');
			}

			const uniIdToken = this.getUniIdToken();
			const result = await batchSoftDelete('dh-hospitals', ids, uniIdToken?.uid || '', reason);
			
			return formatResponse(result.code, result.data, result.message);
		} catch (error) {
			return formatError(error, '批量删除失败');
		}
	},

	/**
	 * 更新医院评分
	 */
	async updateRating(id, rating, totalReviews) {
		try {
			if (!id) {
				return formatResponse(400, null, '医院ID不能为空');
			}

			await db.collection('dh-hospitals').doc(id).update({
				rating: rating,
				total_reviews: totalReviews,
				update_time: Date.now()
			});

			return formatResponse(200, null, '评分更新成功');
		} catch (error) {
			return formatError(error, '更新评分失败');
		}
	}
};

